{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys \n",
    "\n",
    "# Modify the path \n",
    "sys.path.append(\"..\")\n",
    "\n",
    "import pandas as pd\n",
    "import yellowbrick as yb\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.model_selection import train_test_split as tts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "occupancy  = pd.read_csv('data/occupancy/occupancy.csv')\n",
    "features = [\n",
    "    \"temperature\", \"relative humidity\", \"light\", \"C02\", \"humidity\"\n",
    "]\n",
    "classes = [\"unoccupied\", \"occupied\"]\n",
    "X = occupancy[features]\n",
    "y = occupancy['occupancy']\n",
    "\n",
    "# Create the train and test data\n",
    "X_train, X_test, y_train, y_test = tts(X, y, test_size=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Current functionality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/peter/.pyenv/versions/3.7.0/lib/python3.7/site-packages/yellowbrick/contrib/scatter.py:211: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  X_two_cols = X[self.features_].as_matrix()\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAETCAYAAAAs4pGmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmcFPWZ+PFPD+MACnLIIYgRGeUh4dTWgDpyeBFIDEZNIq4rmBjW/IxRYxLFeOCaVTTExJjELB4B3WC8xQOCG8UDVyO2BwyYBwRREQRGg4LijMP074+qGmp6qq+Zvvt55+Ur3VXV1d9v9/B9+nuHotEoxhhjTKyKfCfAGGNMYbIAYYwxJpAFCGOMMYEsQBhjjAlkAcIYY0wgCxDGGGMCVeY7Aab0icgY4HpgP5wfJe8BP1XVVW2835HA91X1PPf5k8CZqlrXjjTOA04EtgFRYC9gHfADVd0qIhuA01X1lVTTleC6WUAvVf2RiCzC+SxWJ0lbrarOCTh3FfCGqi5MmME2EJGjgauA/XHKineAS1W11j3/dZzvtSOwAifvn4hIZ+APwJE43/c/gPNVdVem02iyy2oQJqtEpCPwOHCJqo5Q1WHAX4DFItKhjbcdCgzwPT+xncn0/EZVR6nqYW463wL+2I50JaWqkxMFhxQchxPMMkpExgJ/BX7hfibDgAXAsyLSW0R6A38GTlNVAdYDs92X/wInoIwERgCdgZmZTqPJPqtBmGzbG+gOdPEd+wvwCdAB2C0i3wMuAXYDdcA04H3gN8AYoCsQAs4F3gX+E+gmIn/23XOpiEwGmoDfA1/CKTj/qqrXichA4HngTWAgME5VNydJ+1PAjbEHRWQG8GM3vVuAHwG7/OlS1XPc2sGfVPXReG/gr5mIyGXA94EdwHPAKao60L30aBH5P6AvUAucCUwHjgB+JSK7VfVh330XAK96tQ4ROQ+Y4N7/z8Ch7mcVAf5DVZtiknYNcK2qRrwDqvoXEfkc53s7Hliuqmvd07cCb4jI+W7aN3j3FJHXcIKnKTJWgzBZpar/An4O/E1E1ovI3cA5wN9VtUFERgI3AF9T1RHAozi/QEcD/YGjVPUrwHzgMlV9D6fZ43lVPUdVz3HfaoJ77m7gTlUNA18FThCR77jXDMAp9AYnCw5uM8nZwNKY48e5+ZmgqiNxflU/Amz0p8vN++REwSHmvhNxCvwjgTBOUPQ7ADgBGOzm41RV/QPwCvAzf3Bw3YYTaD3nuMe+BXRV1VHuewEMCkjSEcALsQdV9UFV/QA4EKep0LMR2Ne995OqusbN10HARcD9cTNvCpbVIEzWqepNInIbMA4YC1wKXCoiX8X5JbrELdxR1d96rxORK4D/EJFqYDzOL+u4RGQf9z16isi17uEuwCjgZaAReDHBLS4WkbPcx5XAs7RuGvkacK+qbnPTO09EbsaplbTHZOB+Vd3u5uUPOJ+N5xFV/cw9Vwv0SXK/Z4BOInIE8BnQG6dGNBC4TkSeAf4X+K2qvhXw+iYS/4CMd26390BEwsDDwO9V9fEk6TUFyAKEySoROQY4WlV/hdMX8biIXA6sxOk7aMTpFPau7wwcBFQDNwO/BhYC/wTOIrEOOE1RR/sK017A50AvoF5VGxO8/jdBHcExggrGEO3vB2h07+PZHXP+C9/jaMy1rahqVETuwKkF1QN3qGoUeFtEDsEJuMcBfxeRC1T1gZhbvITTvFfrP+gGrodxmvpG+04dAPxLVT91rzsDp//mR6q6IFFaTeGyJiaTbduAK0SkxnesH7APTpBYitMM1M899x847f4nAo+p6q3AcuAUnAAATmHqL5B3A3up6ic4BdtPAESkO04zyZQM5mcJ8F23kxYROQf4EKdDOzZd6XgCOE1EurnPv48vcCaQ6D3nAd8Evo3T74CI/NB9/KSqXoqTn2EBr/0lcLVbC8B97XTgdJzv7UlgjIgc6p4+DyeQIyKnA78DTrLgUNwsQJisctuiT8Fp1lgvIquB+4AZ6lgJ/Aynj+INnCac84A/AeNEZAVOs9A64GARqXCfDxERr939IWCZiAzD6bwdIyIrcYZX3qOqf8lgfv4Xp/P8aRFZhdPO/w23Q7ZFukRkkYh8M8X7Po3TR/CiiLwCdMNpGkrmMWCOiEyLPeH2FbwKrFDVTe7hu3AC7Wr3ffbFqanFvvZ5nEEBN4vI6+73dhpO38sWVd2K06/xgIi8CQzHGWgAztDXEHC7+9rX3ZqHKTIhW+7bmPxz+wqOVtXfuc9/AoxW1e/mN2WmnFkfhDGFYQ1Ox/0MnKald4EZ+U2SKXdWgzDGGBPI+iCMMcYEKokmpkgk0hFn0s9mWg8PNMYYE6wDzqjC5eFwuD72ZEkECJzg8Hy+E2GMMUXqWGBZ7MFSCRCbAQYPHkxVVVXgBbW1tQwbFjTcu/RYXktXOeW3nPIK+clvQ0MDa9asAbcMjVUqAWI3QFVVFR07dox7UaJzpcbyWrrKKb/llFfIa34Dm+atk9oYY0wgCxDGGGMClUoTU1lraGxk6bqtzc/XbtpBXZdNzc8nVPehqtK+amNMeqzUKAGL39zIqfNiBnE9s2ep/oemH8uU4QNzmyhjTNGzJqYS8Ejt++06b4wxQSxAGGOMCWRNTMaYorS7qYl1H+6Me756vy50qLDfwO1hAcIYU5TWfbiTL89eGPf8m5dNYXDvfXOYoux67rnn2Lx5M9/9bvIV4J977jkWLVrE7Nmz2/WeFiCMMaYIjB07NufvaQHCGGNiPPTQQ6xfv56f/vSn1NfXM2nSJA444ACGDBnC2rVr2blzJzfffDMHHHAAd955J0888QSVlZUcccQR/OxnP+Ojjz7i0ksvZceOHUSjUW644Qb23XffVscee+wxevXqxdSpU3n//ff57W9/y913383kyZM54ogjWLt2Ld26deOmm27ib3/7W3Oa7r77bh5//HFCoRCTJ0/m7LPPZt26dVx++eV07tyZzp07061bt+QZTcICRAk4eL8u7TpfqOYtuwyA6TXtqyYbkykjRozgF7/4Bb/5zW944oknGDduHIsXL+avf/0rlZWVXHDBBSxdupQXXniB4447jqlTp/Lqq6+yYsUKVqxY0epYPJ9//jknn3wyRx55JDfeeCP33ntvc4H/1ltvsWjRIhYscLb7Puecc6ipqeHGG2/kxz/+Mccccwxz585l/fr17c6vBYgS8JOxQqWvM+79jRs5YMCA5uc/rjk06GVFY/6ymQBMq7k+zykx5ci/qdpXvvIVAPbff3/q6upYv349I0eOZK+99gJo/tX/9ttvc/rppwNw+OGHc/jhh7Nw4cJWx2655ZbA96ysrOTII49svva5555j1KhRAKxZs4ZNmzYxffp0AD7++GPeeecdNmzYwIgRI5pfYwHCANClUycuP2F48/NIpIFweHiCVxQ2r+bgiRJtPm61CZMLHTt2ZNu2bQCsWrUq7nWDBg3iz3/+M42NjXTo0IHly5dzyimnUFdXx8qVKxkyZAjLly/nmWeeobq6utWxbt26Nb/P22+/3XzfxsZG/vnPfzJkyBAikQiHHHJIi/c85JBDuP322wmFQsybNw8Robq6mtdee42xY8dSW1ubkc/BAoQpKlabMLlw7LHHcs899zB16lSGDh3KPvvsE3idiDBp0iSmTp1KU1MT4XCYE044gXA4zOWXX86jjz4KwHXXXcc+++zT6hjARRddxPLly+nVq1eLe992221s2rSJ/v37c/HFF/P4448DMGTIEI466iimTp1KQ0MDI0aMoG/fvlx22WVceuml3HHHHfTs2TMjK8NmbU9qEdkLuBMYCHQEfgmsBubhbMpeC5yvqk0icjXwdaARuEhVXxaRQ4KuDXqvSCQyEHh72LBhcT+USCRCOBzOVPYKSqu1mNas4dDBg5ufF9NaTPOXzWyuMSTi1SRK+XsNUk75TZbXUpsH4c/vcccdx+LFi7O+/Hd9fb1X2zg4HA5viD2fzVLjLOBDVf13EekJvO7+d4WqPiMifwKmiMg7wDhgNHAg8CDODnE3xV4LPJzF9Batpeu2MnnuUy0P+tZiWjTjeCZK/xynqrVkv/5TDQ7GAHSoqCipeQ6FKJsB4n7gAfdxCKd2EAaedY8tBk4CFHhSVaPAuyJSKSK941ybMEAka3eLRCLp56IIrN20I/H5NWvotTNww6ic8or+oO9h5a4HfFck579HqX6v8ZRTfsspr7Anv7/61a8y1o/QHlkLEKq6E0BEuuIEiiuAOW4gANgBdAP2BT70vdQ7Hgq4NqFybWKq67KpRY0h1qGDBxPOYw3Cqzl4AaB21wPN56bVXO+eT6/m4H2Xpfy9Bimn/JZTXiE/+fU1MQXKagOdiBwILAXuVtUFgL8PoSuwHfjEfRx7POhaU6JChPKdBGNMjKzVIESkL/Ak8CNV9RrIXxOR8ar6DDAJJ3i8BdwoInOAAUCFqtaJSNC1pgh5fQ7x+iC857HDW+Oxoa7G5EY2+yAuB3oAV4rIle6xC4HfiUgV8CbwgKruFpHngRdxajTnu9deAtzmvzaLaTUFIETIOqmNKSDZ7IO4ECcgxBoXcO0sYFbMsTVB15rSZkHClIu5c+cyZsyY5tnPicyZM4dBgwZx6qmn5iBlexTH4HiT0ITqPiyacXzz86B5EIUg2eS2dJuajPHcv9xpdvz2kcXztzNjxox8JyEpCxAloKqyssU8h147N+d11FJ7WS3C5NMXX3zBzJkz2bhxI7t37+acc87hgAMO4LrrrqOpqYm+ffsyZ84cVLXVsR/84AfMmjWL6upq7rnnHurq6vjWt77FhRdeSO/evdmyZQtjx47l4osv5rLLLmPy5MkcddRRXH311axatYq9996biy66iNGjR7NkyRJuvfVWevbsyRdffMGgQYNy/llYgDAFx4KDSZVXc/i0fnuL59D22sS9995Lz549mTNnDjt37uTUU0+lqqqKm2++merqau6//37WrVvHVVddxU033dTiWDzvv/8+d9xxB127duXMM89ssb7T/fffT48ePbjqqqsYNGgQZ511Fo888gizZ8/moYceonv37nmrbViAMEXFhsOabFu3bh1HH300AF26dKG6upqnn36a6upqAL797W8DUFdX1+qYn38ZoyFDhtC9e3fAWTLcvzDfmjVriEQivPDCC3Tt2pXGxka2bdtGt27d6NGjBwCHHXZYFnKanAWIEtBqLaZNO5zJc65iWospGatdGD+vlpDJPojq6mpeeeUVTjzxRHbu3MmaNWsYMGAAGzZsYODAgcydO5eDDz6YPn36tDpWVVXFtm3bqK6uZvXq1fTt2xdwgs6uXbuoqqpixYoVnHbaaSxbtgxwVmfdf//9OfLIIxk6dCi33norvXr14pNPPuGjjz6iZ8+erFy5kv3337/deUtXaZQaZa5Y1mJKlfVBmHz6zne+w5VXXsnUqVOpr6/nRz/6EdXV1Vx++eVUVFTQu3dvpk+fTt++fVsdq6qq4pprrqF///706bNncMhee+3FhRdeSF1dHV/72tcYMmRI87kzzjiDK664gsWLFxMKhTjzzDOpqqriqquu4vvf/z7dunWjMk8/8CxAmIKTLDjMXzbTlvs2WVNVVcUNN9zQ6ri3g5tnxIgRrY6NGzeOceNajs7fuHEjvXr1Yu7cuS2Oz569p7/kxhtvbLXUxvjx4xk/fnxbs5ERFiCMMUWvmIa3FpPiWSzdGJc1P5liMmDAAO677758J6NNrAZhCsaeVV+NMYXAahDGGGMCWYAwBcM6no0pLNbEVAKKZS0mY0xxsQBRAkppLaZpNdfbYn3GFAhrYjLGGBPIahAloJyW2jDG5I6VGiXgsVWb+M5dz7Y86Ftq476zx3HayC9l7P3ibR1qjCkt1sRUAhauerdd5wtJKnMhbE9qY3LDahAlYP2HH7frfKq8wtubyewvzK02YUzpsRpECXj13Y/adb6QTKu5PumeDzbKyZjcsBpECWhoat/5VHm1hGz3QdhaS8YUhqwGCBEZDdygquNF5K+At+PFQOAlVT1DRBYCvYAvgF2qOklEDgHmAVGgFjhfVTNUzJWeZMWpFbfGmLbIWoAQkZ8D/w58CqCqZ7jHewBLgYvdSw8Fhqqqvxy7CbhCVZ8RkT8BU4CHs5VWU1i8JiarSRiTX9msQawDTgXujjl+DXCLqm4Wkb5Ad+AxEekOzFbVx4Ew4I3bXAychAWIgpHtDmkLDMYUhqwFCFV9UEQG+o+JSB/gePbUHqqAXwM3Az2BF0TkZSDkq1HsALql8p61tbUJz0cikVSTX3JKLe/+/JRa3pIpp/yWU16h8PKb607q04EFqrrbff4B8CdVbQS2ishrgAD+/oauwPZUbj5s2DA6duwYeC52O7+SsmB10kuKKe8rl92f9BovPyX9vQYop/yWU14hP/mtr69P+MM618NcT8BpMvI/vx9ARLoAw4A3gddEZLx7zSTg+Rym0eTZ9JrZSYe6GmOyL9cBQoD13hNVXQysEZGXgCeBy1W1DrgEuEZEXsRphnogx+k0xpiyl9UmJlXdAIzxPR8acM1FAcfWAOOymTZTuGzrUWMKg02UMwUn0Sgma3oyJncsQJiiYkNgjckdW4vJGGNMIAsQpqBY/4MxhcOamExRmrfsMkKEGNb59HwnxZiSZTUIY4wxgawGYYpOiFDzelCFtjSBMaXEahCm6NhIJmNyw2oQJiMaGhtZum5r3PMTqvtQVZn8zy3Vwn/+spm2zakxWWYBwmTE0nVbmTz3qbjnF804nonSP4cpMsa0lzUxmYJiM6WNKRwWIEzBmL9sZspNTNYPYUz2WYAwxhgTyAKEKRjW6WxMYbEAYQrK9JrZKV9ry3IYk10WIIwxxgSyYa4mIyZU92HRjOMTnk/V9JrZzFt2Wdzz3kinaTXX20xqY7LIAoTJiKrKyozOc5heMzvuqKYoURsOa0wOWBNTmWhobMx3EjLGvxaTMSZ7rAZRJpau21pUM5kTNTFFifrOhwgTzk2ijCkzVoMoEy9v2FpStQhjTPZZDaJMzHpyJaMG9OLkoQPynZSEUh266vVB2IZBxmRPVgOEiIwGblDV8SJyGPA4sNY9fauq3isiVwNfBxqBi1T1ZRE5BJgHRIFa4HxVbcpmWsvByxu2FHyAsKU2jCkcWWtiEpGfA7cDndxDYeAmVR3v/neviBwOjANGA2cAf3CvvQm4QlWPBULAlGyls5w8sGJDvpOQVLqjk1bueiBLKTHGZLMPYh1wqu95GPi6iDwnIneISFegBnhSVaOq+i5QKSK93WufdV+3GDghi+ksG+vqPmOJbmr+rxD7JNIfnWQ1CWOyJWtNTKr6oIgM9B16GbhdVSMi8gvgamA78KHvmh1ANyCkqtGYY0nV1tYmPF/uk6p2Q4s9G24efyBH9e+avwQFaEuNoNy+13LKbznlFQovv7nspH5YVbd7j4FbgIWAv4TqihM0mgKOJTVs2DA6duwYeC4SiRAOl+hwyAWr2/SyQwcPJpzFoa9eh3M6tYLaZQ+kXSco2e81QEn/Hccop7xCfvJbX1+f8Id1Loe5LhGRr7qPjwciwAvARBGpEJEvARWqWge8JiLj3WsnAc/nMJ0mj2wCnDGFI5c1iB8Ct4jIF8AHwAxV/UREngdexAlW57vXXgLcJiJVwJuA9UQWEa/m4I008g9dtQBgTPHIaoBQ1Q3AGPfxq8AxAdfMAmbFHFuDM7rJmKTmLbssrWXCjTGpsYlyJuO8WkJb+iCMMYXDltowxhgTyGoQZca/Z0M6ezTkUohQ2jOl5y+baTUVYzLMAkSZyeWKrm0tsKfVXB93L4h4bOkNYzLPmphMQWpLcEm0RLgxJn0WIEzBmb9sZpsL+1RXgzXGJGcBwhQcay4ypjBYgCgj5dDhZB3VxmSOBYgyUt2jU/KLili6S4UbYxIrhx+VBhjVvzsPTyvdyekhQlZ7MCbDLECUicglJ+c7CVljwcGY7LAmJlP0okRt9JIxWWABwpQECxLGZJ4FCFMybHisMZllAcKUlHnLLrMZ1cZkiAUIY4wxgSxAGGOMCWQBwhhjTKCE8yBEpBJnn+gvAY+o6vO+c7Pc7UKNyZj2jESybUeNyaxkNYj/Bg4DNgF3icjlvnPfzFqqTNmykUjGFI5kM6mPUNWRACJyF/B3EflMVX8LtvBNMVmim5ofT6juQ1WlTaI3xiSWrJSoEJF9VPVTVd0mIpOBZSKyFeynXjGZPPep5sePfG8CJw8dkMfUGGOKQbIAcQvwqoj8UFWfVtX3RWQSsARIuqGxiIwGblDV8SIyyr3fbqAeOFtVt4jIzUANsMN92RRgL2AB0BmneescVf2sDfkre3OnrAJgxsKhzcdWbv6XBQhjTFIJ+yBUdS7wDWCt79g/gaFAwt5EEfk5cDvgrTF9M3CBqo4HHgIudY+HgYmqOt7972PgKmCBqh4LvAb8R5r5MsYY006pNER3AKaJyACgCecX/WK3HyKRdcCpwN3u8zNUdbPvfT8XkQrgUGCuiPQF7lDVO3FqFNe51y52H/8mWUJra2sTno9EIsluUTK8mkOHipbPAV5d34tIpCEfycqiUNl8v+WSTyivvELh5TfZMNf/B8wAHgCWu4f7AbeLyP+o6q/jvVZVHxSRgb7nm917Hg38CBgL7IPT7HQTTiBaKiKvAPsCH7sv3QF0SyUzw4YNo2PHjoHnIpEI4XA4ldsUnwWr07r8gAEDCIeHZykx7bNy2f1tfGW0dL9fn3nLZhKiPHbOK+l/swHykd/6+vqEP6yT1SAuAkbFtv+LyE3Aq0DcABFERL4L/AL4utvp3QG42bu/iDwNjAQ+AboCu9z/357O+5g9fQ5BfRDXTspLkrJu/rKZLYbJ5mKfCG/eRjkU2IXIPv/sShYgvsDpMI7V2T2XMhE5C6cvYbyqfuQeHgzcKyKH4fSH1ADzgReAycA8YBLwfKsbGhOjlOdQ7JlA6OTSP6GwkAtHK8CLW7IA8V/AayLyFOD1H/QDjsOpCaTErSn8DngXeEhEAJ5V1atF5G7gJZyAc5eqrhKRXwLzReQHQB1wZhp5MkmM7JdSi13OZXo/hyjR5pVdM12biF0xNl6BbQVkdnifq/ejoFgCZrFJGCBUdYGIPAOcAPTHmRz3HPCfqvpespur6gZgjPu0Z5xrfgX8KubYFuBrye5vkvM3LQH07dKRow7qlafUmLbyCr1i6YOwArw0JOukPgxYhDMP4S732H8Bs0VkkqquyEEaTQZt2VnPH15Yw5UTR+U7Ka1Mq7m+VT9Cpng7zrW3cIq310SUKCHf4gJWQGaX9xlaDS27kjUxzQGmquoz3gFV/YWIPIcz8uiELKbNZMnqrR8nvyhPptVcn7UNf7LdR1HKfSDpsgK8NCQLED38wcGjqktE5IbsJMlk2/J3ttHQ2FiW6zG195f89JrZSWs5/ppKpgvI4Z1PL6uhnya/kq3mupc7ma0F91hVdpJksu3tf+3i4Tc25jsZgRoaG7N6/6jvf22RShOY1SRyZ1rN9VY7yaJkPyGfBa52//O7AnglKykyGRU0DwLg9n/8k++GB+YkDQ2NjSxdtzXuef/qskvXbSXqlq+hDKwXHI3Gv09b+iRSLfwz0d9RCuwzKG7JAsRMYJGI/BvOTOoQcDiwFdsPoqit3fZxiyXA/Y45qCcvvPNR4DlIf7nwpeu2tlhNNtaiGcczUfo3P2+KQkUbgkMmA0t7+YfY2kZGplglG+a6Q0TGAhNwNg5qAv7g31nOFKZEazHNWDiU9z5piFtoXztpFFcufj3uvWML9EIQjfPDPlGwaMs8iVT6IIwpFUl/BqpqFHja/c+YjNkTtI5v133iBYdE17W1lpHuCCurPZhiVn7DWMpEorWYSlmqBX9sc1QqTUJtmeltzUymmFmAMDkX2/y1edstzN/mPN6/9wVp9z80F/IJahJBtYdE18cGA2tSMuXIAoQpGUG1B38QCOr8Dhrl5G9GCrVj63WrNZhiZwGixBVi01Js89eAvhc0d3o3NDayYFv23vf2U1Y1B4VQKHn/RSo1B6+DO1szwI3JFwsQJusmVPdh0YzWHdGbt61uPu/J5uzuuVNWxa1lZGJobIiQNUWZkmIBosxdO2kU4QP3a3HsmIN6tjrm5y/QU1FVWRk4LNbrd8hmUPDXEvzNS6mOfII9NYSgDYn8bFKYKTUWIMpc+MD9AgvvXMxzyEeBGtsnAckn5XkrwcbWDiwgmFJnAaLMnH3EIA7tvS8j+3WjsrIy7dpArmSq2Qf21CJiRy9VhODcR4by6PfGse1ff3SudWsFscEgqOkoW5sRGVMoLECUmTMOP7jgZkHHSqf5x7veX/gHBRb/Mf+1t5+yiq0frW4+t6n+zObguXnbLc712DBXU54sQJiiF1T4p2dP4d+36i98805vlJVzvEOCNY+t9mBKmQUIU7KSLd6XaJjr3CmrUpqwZzULU8osQJi40lmmOxf3SVdsYAhqfop93iHkNDul/B7tmEhnTKGzAGECNTQ2MueZNxOu6nrCoX2556waenbZO+G90l3uO12xBX9QzcE7luqS4KksxwE2ksmUtmQ7ypkScfYRg1g04/iURy0t0Q8SBgeAv6/dwiWPvZaJ5LVZvFpBsgCQbke4MeUoqzUIERkN3KCq40XkEGAeTo9gLXC+qjaJyNXA14FG4CJVfTnetdlMa6lbsekjDt6vC5H3PmR4vx5MlP0TNuu89v6HOUzdHuluOZqtzYGSBRDrnDblIGsBQkR+Dvw78Kl76CbgClV9RkT+BEwRkXeAccBo4EDgQeDIoGuBh7OV1nLw+qbtvL5pe/PzZM06b3+4M637J+pniLzXMtgkWoJ8wUtXANkp+L2Jcf41meK9V6L3t34HUy6yWYNYB5wK3O0+D+PscQ2wGDgJUOBJd1Oid0WkUkR6x7k2aYCora1NeD4SiaSZhdK1ds0aeu3cHPf81q3xO5X96urqiEQivLhpBxc+816705LJph//vc59pGUw8lZ2DerITmZY59OB/P09ldPfcTnlFQovv1kLEKr6oIgM9B0KuYEAYAfQDdgX8P+89I4HXZvUsGHD6NixY+C5SCRCOBxOPQPFZMHq5NfEOHTwYMLnDayyAAAXMUlEQVRxahA7P/+cfy56O6X79OrVi3A4TF2XTZAkQMTbBrVDxWrCYae5ZuWy+5OvsJrCLOu2Bppk9833Et4l/Xcco5zyCvnJb319fcIf1rnspPb3IXQFtgOfuI9jjwdda3LkpueUDdt35fx9vU16MrKyagr3aPIFEeu0dsxfNrNNO+eZ0pTLAPGaiIx3H08CngdeACaKSIWIfAmoUNW6ONeaDGpojN/nn27/QyqunTSKAX1/zIC+P8ZZvCLU/PzMMdcCqU86S2Ufh0S8SXBBmwclum9s7cEK0+Jl311qcjkP4hLgNhGpAt4EHlDV3SLyPPAiTrA6P961OUxnWfj986upoIlKdyRTWyarjerfnV+ffBgNjY2tOqJj+VeN9Zb59neSZ+Mfq38uw9wpq5ixcGirGdJWc3B4n78XpP3fR6ZHa3n3tlFghS+rAUJVNwBj3MdrcEYsxV4zC5gVcyzwWpM5f1+7hb+v3dL83L8vxGcNDUlfv09lBc+efyJdOnViiW5KOmci09JthqrwzZBuS8e0Xy4LU5NZ9t2lx2ZSG4AWBfzA7p2TXt+naye6dOrUpvcK+oeYzS07U13pNVGgKPWhrd53ks1f91Y4Fx8LEKaV7Z9/kfSakFuqNjQ28vKGxENiZ500POEM7ly1Bbel8zto1FIuClOTHfbdpccChGll++fJZzN3qXL+dJau28qsJ1cmvLZDhw5Z3VY0VqqbDQVNlGuKOgv2mcyzwrn4WIAwbTJsf2dqSqLRUEGCCgfvcXubmLzAkG4fQ4vX+a4t9WalIFZoGz8LEKZNvNFPr25s35pNDY2NLHjpSqLRaKvVV7O1zlIs//v4RzglKyytMC1e9t2lxgKEaZNBPfcBYMNHyedMrN32SdwOyigQzdBY09i9p/3HPbFvlasgZPawwrl4WIAoE507wFEDe/P0um3tvteo/t25eNwQABqbkjcx3fXKesYdSGCDTabnIaSyz0PC0Uq+13tNXrZyqylXth9Emdi1G449pF9G7nXVScPp0qkTDY2NrP4gtVVQ+vW+gGk11xNy/zet5nr2730B5z7ylYykKR3+fgpv9rRNmDOmNatBlJF0ltDwT5yL5Q1ZXaIftFhCPJHIex8GDnX1FuzLZlNPqrvIBcn34nzG5JMFiDKyfccOHjj7WN7ctoPGpqZWAWNgzy4cMaAHlZWVCZfemL9sJlHgqXcmJ9zbwe/Kxa9z1eLXmXtKlBAhdn7+efO5oKGl6RTmQf0OscfS3fPBY5O5TDmzAFFGHtVtnDduBJefMLxNr/c2BWqKQlM0yoJXNzD+wNRfHwV+4O7L8Nb21YwdvH/ra9rwaz9e4Z9Ks5G/fyFbM7mNKVYWIExC/p3iNm29haZolA4Vzi/+209Z1Vw4ezUJSF6bAPjbmvebA0RFkl/67Rdyg0XLobT+5qN4wcG/wuz8ZTOtFmHKinVSm4SW6AdMnvsUk+c+RVMWenJnLBxKUxY6if2T38459vpWu8f5J8GlutRHlKgtEW3KitUgTFwNjY08tOKd5udezcDf75BqH0Qi/j2iM1WDSLandGxNIEQopf0ookRt+KspGxYgypC/2SiI10G9dN1W7nplfbvfL14QmVDdh0Uzjgdg87ZVWR1qmqgg968RlOqmRZD6BkfGFCsLEGVo6bqtTJ77VNzzi2Yc32Izn7ZIpWZRVVnZ/D7z2j9/r13SDQ4eq02YUmYBwqTNX+gnCgAVISdQdHB7uvwd2X9cfkyLa6fXzKbDJXfH3dSnPeYtu6y5zyFbhbjVJkwpsgBRZiZU90nYvNReXhDwgkK8URDSZ9+4r83H+khtbWbylOPKr6b0WYAoM0fdvJhPUtgQKJO8vgWvttG3S0dqf3Zkq+sqsjmbGmeCXraGqloNwpQiCxBlJtWlMdrKCwKxTUXR6J4awn2rj6Nnl70z/t65XCLcmHJgAcLkXXNHbzsL94wNkXU7nFNpbrK1mkwpy2mAEJHpwHT3aSdgFDAVmAO85x6/Gnge+CMwEqgHzlXVt3KZVrNnGGrkvQ+5cvHrab22yStXY5qXAO4765AMpTA9XjPTEt0UeL6hsclNbpR5y2aCNRuZMpfTAKGq84B5ACLyB+BOIAz8XFUf9K4TkVOBTqp6lIiMAX4NTMllWsvJv4UP5t/Cg5qfe6uu+oehpit2Up2ffvgpS3QTm7fd0upce1ZeTUUU2Ljld3HPe53riXa4m14z29ZtMmUhL01MInIEMFRVzxeRxcBhInIR8DJwKVAD/A1AVV9yrzdZ0iEUave8h3R4tZG5U5xo0ME31ClZYIi3cmuqr4doc2d4U5IKgv+9YlectaYlUw7y1QdxOXCN+/h/gUeAt4E/AecB+wIf+67fLSKVqtqY6Ka1tbUJ3zQSibQ1vSWtrq4u4WezdtOONt870TwJf4d2qLlkT2G5i2jLzu90+GsoHWJqCP41obzgUeE+nrFwKDePP5Cj+ncN/KxW7nrATXuI4Z1PTy9RaSqnv+NyyisUXn5zHiBEpDsgqrrUPXSnqm53zy0ETsMJDl19L6tIFhwAhg0bRseOHQPPRSIRwuFwu9JesBasbtfLe/Xq1eKz8Zbi+LyhgQdXbGTVB20PEKkIhZxZBNNqrk/adOMt493WvaVDIdjd1Hr/CUg+zPbQwYMJB9S0WqY5mtW/s5L+O45RTnmF/OS3vr4+4Q/rfNQgxgJPAYhICFghIker6kbgeCACbAFOBu5z+yBW5iGdZWPJmxsJ//oxLqn5Mt8cOYAblr7JdX9PXBvLhraulBq04VAi/kUGoXVg8GoXu5uCz/sFpdmW3zClIh8BQoD1AKoaFZFzgYdEZBewGrgN2A2cKCL/h7PX/Tl5SGfZ2PJpA1s+beDf73uRUcu6Z32uRKx+vS9govRvU4BI1o/Q2p7S3iv4YzujU71/stqOTZ4zxS7nAUJVfxXz/EngyYBLz8tNioxfroODpz3BIZUZ2F6nsjPENf5ChdB65nd7eOtAWU3CFCObKGeyblDPfVj/0acJr0n117a/E9k/lLaCxP0Q3tyHYw7q6S4xfrw7zLbl+/rv4S1F7vGG/0Lbm8OMKSYWIEy7VFU4jTb1TfGvufEbh7N3p6q45ydU92FBCst9+5t/ZiwcyhUnDGVgl/tanPePbmqKOrWLpijNy5tfO2kUPx3/ZaoqK5m/LfGYqUwN/bXagylWFiBMu4w5qBcH9ujClh276LF3FWu3OSOemqJwwegXAHhwxZfY9mk9Yw7qRce99gJgeL8eVFW2fcdbZ62nPR3NsbWHUCh4JdkrF79O+MD9mCj9mwtuf19COvMbUt2FzphiZQHCtMtzb9fB23WB57xf/Pe8/i4Af1+7JfC6vYA/THFqIhVpxoxMzLhua0Gf6mu85iirSZhiYwHCZFzsnhD+IaX+jt/YXedSLaLjBYWgJqbY92wvr7BPd2tS2y/CFCMLEKYgJBuJlMqMaX/g8DcxzZ2yKmGQyMUve6s9mGJkAcJkXOxCfbGFc6IaRjZUhJw+C//Ip2S82eSx9u99AZu3xV/sz8+Gt5piZwHC5F3QhLVEUl1mw1uWoy2WrtvaPPIp1u2nJH5fY0qFBQiTc/GWAu/g6z8IGpUUr7BPtJOc/3gHtyaxedsq5m+L/+u+obGRyHsftjjmpTWdYGa1B1PsLECYjIvXtBSPtzaSV9CnUviGEgSTVF6XyNJ1W1tskDR3yqoWfSQppc86pU0JaPtAdFPU5k5ZlfW2/3SkslyGX4gQ02tmJ9wbwlv1tXmJb9//Uv117wWHUCj14AXOyCXbVMgUO6tBmIxJdXhr7DHvulRqBc3XEHWHnIaY7lsmPHYkk59/aKq3RtLUMdey4KUrifoiSxSYOyX9vhFjSo0FiBKTrHkn3UI825wZ0ek1K3m8Ar+tv9SjRPnLi1e0Pp6BydHZ3HHOJt6ZXLEAYVJWASRYcimp744aSMfKCgZ035uN2z9zj7Zu5sr1L/bY94vdWyJRjSbonG1HakqFBYgSkWrNINkchViH9OhM+Eu9aGzczZtbPubNuk/bvPrQtK9Wt1oAb/6yx4H87Z3QlppLvsxfNtP9lKLNzz1WmzDZYAHCBJp10nCunDgKcJbKjjcnwM+/x7T/eSKFvNhduiOkrOZgSo0FiBKRbs0gmcMH9Gzza/27sJ06fABnH3koVZUVLfZT8KS6UJ6/XyBTv+hTuWfzCKg4o6VCIThzzC+pqsz+P6VpNdcTiUSo3fVA83NjsskCRJlKFkAqAwq8tgSfc48SJkr/5qUrGhqbWLn5X83n1277BmMHPAYkLviDCuj2BopkQSHR+4VCtpSGKX0WIEygVJqU4vEHkIZGp1s70dIVYwekd/9MjDJKdl9v3Sb/PAhjyo0FiBKTjaGq7Rka+9CKd6iqrCDy3oeBNZDYORCpSHRtvCahtvLSese3VuNfkDyf/Q1WazG5YgHCZNVdr6znrlfWA87ks1jpLPOdy1/xXmC4euIIRh/UmwnVU3PSz2BMIbG/eJNUezvAE9VAvH2j07HbnYwRO9M5WdNTUIe4/zXnPtI6X6MP6p2xvamNKTY5DxAi8irwifv0beC/gZuBRuBJVb1GRCqAPwIjgXrgXFV9K9dpNdk3Y+FQbj9lVbs6nb1C3r/fwx3fcoJQbFOQM5dgT1TwrxJ77aRRLa4d2a9b4MgrY8pFTgOEiHQCQqo63nfsdeA0YD3whIgcBhwMdFLVo0RkDPBrIKCBwhSDttZAYn/d337KqhZBJFHto1/vHwf+8ve338eu33T5CcNTSpcx5SIUzdaQkAAiMhq4C3gHJzjNAv5bVb/snr8QqAL6AS+r6l/d4++r6gHx7huJRAbi1EbK0lcXrM53EhKKXTU2NkAkWo8ptnYwY9h+zK0N3qthxsKhnDe8F1/erzPhPvtQVWmLFRuTooPD4fCG2IO5bmL6DJgD3A4cCiwGtvvO7wAGAfsCH/uO7xaRSlVtTHTzYcOG0bFjx8BzkUiEcDjcjqQXsAIMEJmasOfxagr9DjiARUfvaQpau2YNA/oeD8CiGTChuk9gZ3K8LUQ98V6Xrmy/T6n8HafyOa184w3C4XDOvrt8y8d3W19fT21tbdzzuf5U1wBvqWoUWCMiHwP+KbtdcQLG3u5jT0Wy4GAKT0XICRRe57TXuTx3yqoWgcNrPoq3kxw4NQlnTsJqJsqeZqJeOzcTTqETOdE8DIBFM47PSGd0rt6n2KXyOfVK41r7TLMj1wHie8Bw4P+JSH+cQPCpiFTj9EFMBK4BBgAnA/e5fRArc5xO00axI5biNfK0pYaR7mgnY0z75DpA3AHME5FlOLOOvoezgvRfgA44o5j+ISLLgRNF5P+AEHBOjtNpkki1gG+K7gkSQRPkUuHvJntu4zfsj8GYHMlpgFDVBuDMgFNjYq5rAs7LSaJMRgWNWPIHg0RzIpJpyt14CmMMNlHOpClbO9J5hX8Ftu6RMYXCAoTJulQ2LEq2KJ4XQA7er0v2EmqMacEChElLqpPe2lKbaIru2e4z3hIYj36vR9r3Nca0jQUIUxBiaxKe2H6HoH0qUjGhug+LZhyf8Hwm5Op9il0qn9PKNzanfK3JDgsQJi9mLBzKVSeNYNGM3s0TnR584122f+zUTDLdIV1VWZmTsfK5ep9il87nZJ9p/liAMG2SiRnSYwa2XCn15KH9WfBSiGgUtjTsGex27STn/4f362G/Fo3JIQsQJif269SB/vt25mfjR9KreyegddNAVWUl020zHGMKhgWIEvDriSO5ZMkbOX3PvvvsxT4dq+i/b2c6hEJ8XP8FAD06V3H0oD50cvsKhvfrwUTZvyTWyjGm3Ni/2hJw0UkjuOikEYCzCNrvHn2OVfXBixYevF8XfjJWqKqsZOm6rTQ2NvLG5o/5YncTGz7a2XzdgO57s3H7ZwzquQ8dOnRgeL8eLVZHLZUF0owx8dm/8BJTVVnJhIO68dMUVoX02v+/nvltrI0xJcAWzDfGGBPIAoQxxphAFiCMMcYEsgBhjDEmUKl0UncAaGhoSHhRfX19ThJTCCyvpauc8ltOeYXc59dXZnYIOh+KRot/kf1IJFIDPJ/vdBhjTJE6NhwOL4s9WCo1iOXAscBmYHee02KMMcWiA9APpwxtpSRqEMYYYzLPOqmNMcYEsgBhjDEmkAUIY4wxgSxAGGOMCWQBwhhjTKBSGebaTERCwEZgrXvoRVWdKSInA1cBjcCdqnqbiHQG/gfoA+wApqnqtnykOxNEpAL4IzASqAfOVdW38puqzBCRV4FP3KdvA/8N3IzzfT6pqtcUe/5FZDRwg6qOF5FDgHlAFKgFzlfVJhG5Gvg6Tr4vUtWX412bjzykKiavhwGPs+ff7K2qem8p5FVE9gLuBAYCHYFfAqspku+2FGsQ1cCrqjre/W+m+yX9BjgJGAfMEJG+wA+Blap6LHAXcEXeUp0ZpwCdVPUo4DLg13lOT0aISCcg5PtOzwH+BJwJ1ACj3UKmaPMvIj8Hbgc6uYduAq5w/zZDwBQRORzn73c0cAbwh3jX5jLt6QrIaxi4yff93lsqeQXOAj500/s14PcU0XdbcjUInD+2A0RkKbALuBgncr+lqv8CEJFlwFicwuVG93WLgStzn9yMqgH+BqCqL4nIEXlOT6aMBPYWkSdx/mZnAR1VdR2AiCwBTsCZ8FOs+V8HnArc7T4PA8+6jxfj/LhRnNpSFHhXRCpFpHecax/OVcLbICivIiJTcGoRF+H8LZdCXu8HHnAfh3BqB0Xz3RZ1DUJEvi8itf7/gA+A61V1AnAdThPSvsDHvpfuALrFHPeOFbPYfO4WkVL4EfAZMAeYCJwH/Nk95gn6PqGI8q+qDwJf+A6F3MIC4ufPOx50bcEKyOvLwM9UdSywHria0snrTlXdISJdcQLFFRTRd1sU/3jiUdU7gDv8x0Rkb5wojaouE5H+OB9sV99lXYHtOG3aXWOOFTN/fgAqVLUxX4nJoDU4NcAosEZEPgZ6+s57393elE7+/e3MQX+v/uNB1xaTh1XVS/PDwC3AQkokryJyIE6+/qiqC0TkRt/pgv5ui7oGEcfVOFVURGQk8B5Op9ChItJTRKpwmpdeBF4AJruvm0TxL/jXnB8RGQOszG9yMuZ7uP0JbsDfG/hURKrdQQkTcb67Usr/ayIy3n3s/W2+AEwUkQoR+RJOAKyLc20xWSIiX3UfHw9EKJG8un2dTwKXquqd7uGi+W6LugYRx2zgf0TEGw0wXVW/EJGfAEtwguKdqvq+iNwKzHf7JBpwOj2L2cPAiSLyfzjtnefkOT2Zcgcwz/2eojgBown4C85iY0+q6j9EZDmlk/9LgNvcHzRvAg+o6m4ReR7nx00FcH68a/OR4Hb4IXCLiHyB00Q8Q1U/KZG8Xg70AK4UEa+P80Lgd8Xw3dpifcYYYwKVYhOTMcaYDLAAYYwxJpAFCGOMMYEsQBhjjAlkAcIYY0wgCxDGtIOIjBeRZ0Tk9kRLe4jIQBHZEOfcn0XkoGyl0Zi2KsV5EMbknKqe246XTwCuyVRajMkUmwdhTDu4s1xnuU9nqeozInI9cDpQB2wGHgWeAf4BLAWGAf/CWX32B8B/Am8Bx6rqhzlMvjEJWROTMRnk7jtSAwzFWfbjMN/p3jjLWg8DtgBnqOpsYBMw2YKDKTTWxGRMZp0I3KeqDUCDiDziO7dJVV92H68CeuU8dcakwWoQxmTWbuL/u/KvLBvFWS/KmIJlAcKYzPpf4DQRqRKRfYFv4ASDRBqx2rwpQBYgjMkgVV0EPAe8BjyB07+wK8nLHgcWicjBWU6eMWmxUUzGZJCIHAUMVtX57l7oLwLfU9UVeU6aMWmzAGFMBolIT2ABzv7YFcB8VZ2T31QZ0zYWIIwxxgSyPghjjDGBLEAYY4wJZAHCGGNMIAsQxhhjAlmAMMYYE+j/A4jAmWrz6ZeFAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from yellowbrick.contrib.scatter import ScatterVisualizer\n",
    "\n",
    "visualizer = ScatterVisualizer(\n",
    "    x=\"light\", y=\"C02\", alpha=0.1, classes=classes\n",
    ")\n",
    "\n",
    "visualizer.fit(X, y)\n",
    "visualizer.transform(X)\n",
    "visualizer.poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import numpy as np\n",
    "\n",
    "from yellowbrick.features.base import DataVisualizer\n",
    "from yellowbrick.utils import is_dataframe, is_structured_array\n",
    "from yellowbrick.utils import has_ndarray_int_columns\n",
    "from yellowbrick.exceptions import YellowbrickValueError\n",
    "from yellowbrick.style.colors import resolve_colors\n",
    "\n",
    "\n",
    "##########################################################################\n",
    "# Quick Methods\n",
    "##########################################################################\n",
    "\n",
    "def scatterviz(X,\n",
    "               y=None,\n",
    "               ax=None,\n",
    "               alpha = 1,\n",
    "               features=None,\n",
    "               classes=None,\n",
    "               color=None,\n",
    "               colormap=None,\n",
    "               markers=None,\n",
    "               **kwargs):\n",
    "    \"\"\"Displays a bivariate scatter plot.\n",
    "\n",
    "    This helper function is a quick wrapper to utilize the ScatterVisualizer\n",
    "    (Transformer) for one-off analysis.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "\n",
    "    X : ndarray or DataFrame of shape n x m\n",
    "        A matrix of n instances with m features\n",
    "\n",
    "    y : ndarray or Series of length n, default: None\n",
    "        An array or series of target or class values\n",
    "\n",
    "    ax : matplotlib axes, default: None\n",
    "        The axes to plot the figure on.\n",
    "\n",
    "    features : list of strings, default: None\n",
    "        The names of two features or columns.\n",
    "        More than that will raise an error.\n",
    "        \n",
    "    classes : list of strings, default: None\n",
    "        The names of the classes in the target\n",
    "\n",
    "    color : list or tuple of colors, default: None\n",
    "        Specify the colors for each individual class\n",
    "\n",
    "    colormap : string or matplotlib cmap, default: None\n",
    "        Sequential colormap for continuous target\n",
    "\n",
    "    markers : iterable of strings, default: ,+o*vhd\n",
    "        Matplotlib style markers for points on the scatter plot points\n",
    "    \n",
    "    alpha : float, default: 1.0\n",
    "        Specify a transparency where 1 is completely opaque and 0 is completely\n",
    "        transparent. This property makes densely clustered points more visible.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    ax : matplotlib axes\n",
    "        Returns the axes that the parallel coordinates were drawn on.\n",
    "    \"\"\"\n",
    "    # Instantiate the visualizer\n",
    "    visualizer = ScatterVisualizer(ax, features, classes, color, colormap,\n",
    "                                   markers, **kwargs)\n",
    "\n",
    "    # Fit and transform the visualizer (calls draw)\n",
    "    visualizer.fit(X, y, **kwargs)\n",
    "    visualizer.transform(X)\n",
    "\n",
    "    # Return the axes object on the visualizer\n",
    "    return visualizer.ax\n",
    "\n",
    "\n",
    "##########################################################################\n",
    "# Static ScatterVisualizer Visualizer\n",
    "##########################################################################\n",
    "\n",
    "class ScatterVisualizer(DataVisualizer):\n",
    "    \"\"\"\n",
    "    ScatterVisualizer is a bivariate feature data visualization algorithm that\n",
    "    plots using the Cartesian coordinates of each point.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "\n",
    "        ax : a matplotlib plot, default: None\n",
    "            The axis to plot the figure on.\n",
    "\n",
    "        x : string, default: None\n",
    "            The feature name that corresponds to a column name or index postion\n",
    "            in the matrix that will be plotted against the x-axis\n",
    "\n",
    "        y : string, default: None\n",
    "            The feature name that corresponds to a column name or index postion\n",
    "            in the matrix that will be plotted against the y-axis\n",
    "\n",
    "        features : a list of two feature names to use, default: None\n",
    "            List of two features that correspond to the columns in the array.\n",
    "            The order of the two features correspond to X and Y axes on the\n",
    "            graph. More than two feature names or columns will raise an error.\n",
    "            If a DataFrame is passed to fit and features is None, feature names\n",
    "            are selected that are the columns of the DataFrame.\n",
    "\n",
    "        classes : a list of class names for the legend, default: None\n",
    "            If classes is None and a y value is passed to fit then the classes\n",
    "            are selected from the target vector.\n",
    "\n",
    "        color : optional list or tuple of colors to colorize points, default: None\n",
    "            Use either color to colorize the points on a per class basis or\n",
    "            colormap to color them on a continuous scale.\n",
    "\n",
    "        colormap : optional string or matplotlib cmap to colorize points, default: None\n",
    "            Use either color to colorize the points on a per class basis or\n",
    "            colormap to color them on a continuous scale.\n",
    "\n",
    "        markers : iterable of strings, default: ,+o*vhd\n",
    "            Matplotlib style markers for points on the scatter plot points\n",
    "\n",
    "        kwargs : keyword arguments passed to the super class.\n",
    "        \n",
    "        alpha : float, default: 1.0\n",
    "            Specify a transparency where 1 is completely opaque and 0 is completely\n",
    "            transparent. This property makes densely clustered points more visible.\n",
    "\n",
    "        These parameters can be influenced later on in the visualization\n",
    "        process, but can and should be set as early as possible.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self,\n",
    "                 ax=None,\n",
    "                 x=None,\n",
    "                 y=None,\n",
    "                 alpha = 1,\n",
    "                 features=None,\n",
    "                 classes=None,\n",
    "                 color=None,\n",
    "                 colormap=None,\n",
    "                 markers=None,\n",
    "                 **kwargs):\n",
    "        \"\"\"\n",
    "        Initialize the base scatter with many of the options required in order\n",
    "        to make the visualization work.\n",
    "        \"\"\"\n",
    "        super(ScatterVisualizer, self).__init__(ax, features, classes, color,\n",
    "                                                colormap, **kwargs)\n",
    "\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "        self.alpha = alpha\n",
    "        \n",
    "        self.markers = itertools.cycle(\n",
    "            kwargs.pop('markers', (',', '+', 'o', '*', 'v', 'h', 'd')))\n",
    "\n",
    "        self.color = color\n",
    "        self.colormap = colormap\n",
    "\n",
    "        if self.x is not None and self.y is not None and self.features_ is not None:\n",
    "            raise YellowbrickValueError(\n",
    "                'Please specify x,y or features, not both.')\n",
    "\n",
    "        if self.x is not None and self.y is not None and self.features_ is None:\n",
    "            self.features_ = [self.x, self.y]\n",
    "        # Ensure with init that features doesn't have more than two features\n",
    "        if features is not None:\n",
    "            if len(features) != 2:\n",
    "                raise YellowbrickValueError(\n",
    "                    'ScatterVisualizer only accepts two features.')\n",
    "\n",
    "    def fit(self, X, y=None, **kwargs):\n",
    "        \"\"\"\n",
    "        The fit method is the primary drawing input for the parallel coords\n",
    "        visualization since it has both the X and y data required for the\n",
    "        viz and the transform method does not.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        X : ndarray or DataFrame of shape n x m\n",
    "            A matrix of n instances with 2 features\n",
    "\n",
    "        y : ndarray or Series of length n\n",
    "            An array or series of target or class values\n",
    "\n",
    "        kwargs : dict\n",
    "            Pass generic arguments to the drawing method\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        self : instance\n",
    "            Returns the instance of the transformer/visualizer\n",
    "        \"\"\"\n",
    "        _, ncols = X.shape\n",
    "\n",
    "        if ncols == 2:\n",
    "            X_two_cols = X\n",
    "            if self.features_ is None:\n",
    "                self.features_ = [\"Feature One\", \"Feature Two\"]\n",
    "\n",
    "        # Handle the feature names if they're None.\n",
    "        elif self.features_ is not None and is_dataframe(X):\n",
    "            X_two_cols = X[self.features_].as_matrix()\n",
    "\n",
    "        # handle numpy named/ structured array\n",
    "        elif self.features_ is not None and is_structured_array(X):\n",
    "            X_selected = X[self.features_]\n",
    "            X_two_cols = X_selected.copy().view((np.float64, len(X_selected.dtype.names)))\n",
    "\n",
    "        # handle features that are numeric columns in ndarray matrix\n",
    "        elif self.features_ is not None and has_ndarray_int_columns(self.features_, X):\n",
    "            f_one, f_two = self.features_\n",
    "            X_two_cols = X[:, [int(f_one), int(f_two)]]\n",
    "\n",
    "        else:\n",
    "            raise YellowbrickValueError(\"\"\"\n",
    "                ScatterVisualizer only accepts two features, please\n",
    "                explicitly set these two features in the init kwargs or\n",
    "                pass a matrix/ dataframe in with only two columns.\"\"\")\n",
    "\n",
    "        # Store the classes for the legend if they're None.\n",
    "        if self.classes_ is None:\n",
    "            # TODO: Is this the most efficient method?\n",
    "            self.classes_ = [str(label) for label in np.unique(y)]\n",
    "\n",
    "        # Draw the instances\n",
    "        self.draw(X_two_cols, y, **kwargs)\n",
    "\n",
    "        # Fit always returns self.\n",
    "        return self\n",
    "\n",
    "    def draw(self, X, y, **kwargs):\n",
    "        \"\"\"Called from the fit method, this method creates a scatter plot that\n",
    "        draws each instance as a class or target colored point, whose location\n",
    "        is determined by the feature data set.\n",
    "        \"\"\"\n",
    "        # Set the axes limits\n",
    "        self.ax.set_xlim([-1,1])\n",
    "        self.ax.set_ylim([-1,1])\n",
    "\n",
    "        # set the colors\n",
    "        color_values = resolve_colors(\n",
    "            n_colors=len(self.classes_),\n",
    "            colormap=self.colormap,\n",
    "            colors=self.color\n",
    "        )\n",
    "\n",
    "        colors = dict(zip(self.classes_, color_values))\n",
    "\n",
    "        # Create a data structure to hold the scatter plot representations\n",
    "        to_plot = {}\n",
    "        for kls in self.classes_:\n",
    "            to_plot[kls] = [[], []]\n",
    "\n",
    "        # Add each row of the data set to to_plot for plotting\n",
    "        # TODO: make this an independent function for override\n",
    "        for i, row in enumerate(X):\n",
    "            row_ = np.repeat(np.expand_dims(row, axis=1), 2, axis=1)\n",
    "            x_, y_ = row_[0], row_[1]\n",
    "            kls = self.classes_[y[i]]\n",
    "\n",
    "            to_plot[kls][0].append(x_)\n",
    "            to_plot[kls][1].append(y_)\n",
    "\n",
    "        # Add the scatter plots from the to_plot function\n",
    "        # TODO: store these plots to add more instances to later\n",
    "        # TODO: make this a separate function\n",
    "        for i, kls in enumerate(self.classes_):\n",
    "            self.ax.scatter(\n",
    "                to_plot[kls][0],\n",
    "                to_plot[kls][1],\n",
    "                marker=next(self.markers),\n",
    "                color=colors[kls],\n",
    "                label=str(kls),\n",
    "                alpha=self.alpha,\n",
    "                **kwargs)\n",
    "\n",
    "        self.ax.axis('equal')\n",
    "\n",
    "    def finalize(self, **kwargs):\n",
    "        \"\"\"\n",
    "        Finalize executes any subclass-specific axes finalization steps.\n",
    "        The user calls poof and poof calls finalize.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        kwargs: generic keyword arguments.\n",
    "\n",
    "        \"\"\"\n",
    "        # Divide out the two features\n",
    "        feature_one, feature_two = self.features_\n",
    "\n",
    "        # Set the title\n",
    "        self.set_title('Scatter Plot: {0} vs {1}'.format(\n",
    "            str(feature_one), str(feature_two)))\n",
    "        # Add the legend\n",
    "        self.ax.legend(loc='best')\n",
    "        self.ax.set_xlabel(str(feature_one))\n",
    "        self.ax.set_ylabel(str(feature_two))\n",
    "\n",
    "\n",
    "# Alias for ScatterViz\n",
    "ScatterViz = ScatterVisualizer\n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now with alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/peter/.pyenv/versions/3.7.0/lib/python3.7/site-packages/ipykernel_launcher.py:206: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x350 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualizer = ScatterVisualizer(x=\"light\", y=\"C02\", alpha=0.5, classes=classes, size=(500,350))\n",
    "\n",
    "visualizer.fit(X, y)\n",
    "visualizer.transform(X)\n",
    "visualizer.poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/peter/.pyenv/versions/3.7.0/lib/python3.7/site-packages/ipykernel_launcher.py:206: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualizer = ScatterVisualizer(\n",
    "    x=\"temperature\", y=\"light\", alpha=0.7, classes=classes\n",
    ")\n",
    "\n",
    "visualizer.fit(X, y)\n",
    "visualizer.transform(X)\n",
    "visualizer.poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
